#![allow(dead_code)]
#![allow(unused_imports)]
use once_cell::sync::Lazy;
use std::path::Path;
use std::env;
use log;
use crate::config::app_config::AppConfig;
use std::collections::HashMap;
use std::io::Cursor;
use dotenvy::from_read_iter;

mod app_config;
pub mod const_store;

// 引入加密配置模块
#[cfg(feature = "production")]
mod encrypted_config {
    include!(concat!(env!("OUT_DIR"), "/encrypted_config.rs"));
}

// 全局配置实例（线程安全的单例）
#[allow(unused_variables)]
#[allow(unreachable_patterns)]
pub static CONFIG: Lazy<AppConfig> = Lazy::new(|| {
    let app_env = Environment::detect();
    log::info!("当前环境: {:?}", app_env);

    let config = match () {
        #[cfg(feature = "development")]
        () => load_from_file(app_env),

        #[cfg(feature = "production")]
        () => load_encrypted_config(),

        // 默认情况：使用硬编码的基础配置
        _ => {
            log::warn!("使用默认配置，未启用任何特性");
            AppConfig::default()
        }
    };

    log::info!("配置加载结果: {:#?}", config);
    config
});

// 开发环境配置加载
#[cfg(feature = "development")]
fn load_from_file(app_env: Environment) -> AppConfig {
    let config_file = app_env.config_file();
    log::info!("尝试加载配置文件: {}", config_file);

    if let Ok(current_dir) = env::current_dir() {
        log::info!("当前工作目录: {:?}", current_dir);
    }

    if !Path::new(config_file).exists() {
        log::error!("配置文件不存在: {}", config_file);
        panic!("配置文件不存在: {}", config_file);
    }

    if let Err(e) = dotenvy::from_filename(config_file) {
        log::warn!("加载配置文件失败: {}", e);
    }

    // 直接从环境变量创建 AppConfig
    get_app_config()
}

// 生产环境加密配置加载（已移除 unsafe）
#[cfg(feature = "production")]
fn load_encrypted_config() -> AppConfig {
    use crate::utils::encry_util::{ConfigEncrypter, EncryptedConfig};

    // 构建加密配置对象
    let encrypted_config = EncryptedConfig {
        key: encrypted_config::ENCRYPTION_KEY.to_string(),
        nonce: encrypted_config::NONCE.to_string(),
        data: encrypted_config::ENCRYPTED_CONFIG.to_string(),
    };

    // 解密配置
    let decrypted = ConfigEncrypter::decrypt(&encrypted_config)
        .expect("配置解密失败");

    // 使用 from_read_iter 解析 .env 格式的字符串
    let reader = Cursor::new(decrypted);
    let env_iter = from_read_iter(reader);

    // 将解析结果收集到 HashMap
    let env_map: HashMap<String, String> = env_iter
        .filter_map(Result::ok)
        .collect();


    // 直接从 HashMap 创建 AppConfig，不设置全局环境变量
    get_app_config_from_map(&env_map)
}

pub fn get_app_config() -> AppConfig {
    // 收集当前环境变量到 HashMap
    let env_vars: HashMap<String, String> = env::vars().collect();
    get_app_config_from_map(&env_vars)
}

fn get_app_config_from_map(env_vars: &HashMap<String, String>) -> AppConfig {
    // 从 HashMap 解析配置
    AppConfig {
        api_url: env_vars.get("VITE_APP_BASE_API")
            .cloned()
            .unwrap_or_else(|| {
                log::warn!("VITE_APP_BASE_API 未设置，使用默认值");
                "http://localhost:8280".into()
            }),
        app_env: env_vars.get("VITE_APP_ENV")
            .cloned()
            .unwrap_or_else(|| "development".into()),
        timeout: env_vars.get("TIMEOUT")
            .and_then(|s| s.parse().ok())
            .unwrap_or(30),
        sign_config: env_vars.get("VITE_APP_SIGN_PARAM")
            .and_then(|s| {
                log::info!("VITE_APP_SIGN_PARAM 原始值: {:?}", s);
                match serde_json::from_str(s) {
                    Ok(config) => {
                        log::info!("VITE_APP_SIGN_PARAM 解析结果: {:?}", config);
                        Some(config)
                    }
                    Err(e) => {
                        log::error!("解析 VITE_APP_SIGN_PARAM 失败: {}", e);
                        None
                    }
                }
            })
            .unwrap_or_default(),
        login_config: env_vars.get("VITE_APP_LOGIN_CONFIG")
            .and_then(|s| serde_json::from_str(s).ok())
            .unwrap_or_default(),
        login_bind: env_vars.get("VITE_APP_LOGIN_BIND")
            .and_then(|s| serde_json::from_str(s).ok())
            .unwrap_or_default(),
    }
}

#[derive(Debug)]
pub enum Environment {
    Development,
    Production,
}

impl Environment {
    pub fn detect() -> Self {
        #[cfg(feature = "development")]
        log::info!("编译时启用了 development 特性");

        #[cfg(feature = "production")]
        log::info!("编译时启用了 production 特性");

        if cfg!(feature = "development") {
            Environment::Development
        } else if cfg!(feature = "production") {
            Environment::Production
        } else {
            panic!("未指定环境特性 (development 或 production)");
        }
    }

    pub fn config_file(&self) -> &'static str {
        match self {
            Environment::Development => ".env.development",
            Environment::Production => ".env.production",
        }
    }
}